#include "NodeType.h"
//necessary


void printNodeType(FILE* f,NodeType _type,const char* separator){
	switch (_type){
	case NODE_PROGRAM: {
		fprintf(f,"PROGRAM");break;
	}

	case NODE_CLASS_FILE: {
		fprintf(f,"CLASS%sFILE",separator);break;
	}

	case NODE_GROUP_LABEL_FILE: {
		fprintf(f,"GROUP%sLABEL%sFILE",separator,separator);break;
	}

	case NODE_GROUP_LABELS_DEFINITION_SECTOR: {
		fprintf(f,"GROUP%sLABELS%sDEFINITION%sSECTOR",separator,separator,separator);break;
	}

	case NODE_GROUP_LABELS_DEFINITION_LIST: {
		fprintf(f,"GROUP%sLABELS%sDEFINITION%sLIST",separator,separator,separator);break;
	}

	case NODE_GROUP_LABELS_DEFINITION: {
		fprintf(f,"GROUP%sLABELS%sDEFINITION",separator,separator);break;
	}

	case NODE_ID_LIST: {
		fprintf(f,"ID%sLIST",separator);break;
	}

	case NODE_MODIFIER_SECTOR: {
		fprintf(f,"MODIFIER%sSECTOR",separator);break;
	}

	case NODE_MODIFIER_LIST: {
		fprintf(f,"MODIFIER%sLIST",separator);break;
	}

	case NODE_MODIFIER_ELEMENT: {
		fprintf(f,"MODIFIER%sELEMENT",separator);break;
	}

	case NODE_MODE_POLICIES_SECTOR: {
		fprintf(f,"MODE%sPOLICIES%sSECTOR",separator,separator);break;
	}

	case NODE_READ_POLICIES: {
		fprintf(f,"READ%sPOLICIES",separator);break;
	}

	case NODE_WRITE_POLICIES: {
		fprintf(f,"WRITE%sPOLICIES",separator);break;
	}

	case NODE_ACCESS_GROUP_LIST: {
		fprintf(f,"ACCESS%sGROUP%sLIST",separator,separator);break;
	}

	case NODE_ACCESS_GROUP_ELEMENT: {
		fprintf(f,"ACCESS%sGROUP%sELEMENT",separator,separator);break;
	}

	case NODE_TYPE: {
		fprintf(f,"TYPE");break;
	}

	case NODE_SIMPLE_TYPE: {
		fprintf(f,"SIMPLE%sTYPE",separator);break;
	}

	case NODE_CLASS_TYPE: {
		fprintf(f,"CLASS%sTYPE",separator);break;
	}

	case NODE_ARRAY_TYPE: {
		fprintf(f,"ARRAY%sTYPE",separator);break;
	}

	case NODE_REQUIRE_SECTOR: {
		fprintf(f,"REQUIRE%sSECTOR",separator);break;
	}

	case NODE_REQUIRE_LIST: {
		fprintf(f,"REQUIRE%sLIST",separator);break;
	}

	case NODE_REQUIRE_ELEMENT: {
		fprintf(f,"REQUIRE%sELEMENT",separator);break;
	}

	case NODE_FIELD_DECLARATION_SECTOR: {
		fprintf(f,"FIELD%sDECLARATION%sSECTOR",separator,separator);break;
	}

	case NODE_FIELD_LIST: {
		fprintf(f,"FIELD%sLIST",separator);break;
	}

	case NODE_FIELD_ELEMENT: {
		fprintf(f,"FIELD%sELEMENT",separator);break;
	}

	case NODE_METHOD_DECLARATION_SECTOR: {
		fprintf(f,"METHOD%sDECLARATION%sSECTOR",separator,separator);break;
	}

	case NODE_METHOD_LIST: {
		fprintf(f,"METHOD%sLIST",separator);break;
	}

	case NODE_METHOD: {
		fprintf(f,"METHOD");break;
	}

	case NODE_RETURN_TYPE: {
		fprintf(f,"RETURN%sTYPE",separator);break;
	}

	case NODE_FORMAL_PARAM_DECLARATION_SECTOR: {
		fprintf(f,"FORMAL%sPARAM%sDECLARATION%sSECTOR",separator,separator,separator);break;
	}

	case NODE_FORMAL_PARAM_DECLARATION_LIST: {
		fprintf(f,"FORMAL%sPARAM%sDECLARATION%sLIST",separator,separator,separator);break;
	}

	case NODE_FORMAL_PARAM_DECLARATION: {
		fprintf(f,"FORMAL%sPARAM%sDECLARATION",separator,separator);break;
	}

	case NODE_ACTUAL_PARAM_SECTOR: {
		fprintf(f,"ACTUAL%sPARAM%sSECTOR",separator,separator);break;
	}

	case NODE_ACTUAL_PARAM_LIST: {
		fprintf(f,"ACTUAL%sPARAM%sLIST",separator,separator);break;
	}

	case NODE_LEFT_HAND_SIDE: {
		fprintf(f,"LEFT%sHAND%sSIDE",separator,separator);break;
	}

	case NODE_FIELD_VAR: {
		fprintf(f,"FIELD%sVAR",separator);break;
	}

	case NODE_PROCEDURE_CALL: {
		fprintf(f,"PROCEDURE%sCALL",separator);break;
	}

	case NODE_ARRAY_VAR: {
		fprintf(f,"ARRAY%sVAR",separator);break;
	}

	case NODE_NEW_INSTANCE: {
		fprintf(f,"NEW%sINSTANCE",separator);break;
	}

	case NODE_INSTANCE_MODE: {
		fprintf(f,"INSTANCE%sMODE",separator);break;
	}

	case NODE_BRACES_LIST: {
		fprintf(f,"BRACES%sLIST",separator);break;
	}

	case NODE_BRACES_ELEMENT: {
		fprintf(f,"BRACES%sELEMENT",separator);break;
	}

	case NODE_EXPR: {
		fprintf(f,"EXPR");break;
	}

	case NODE_INNER_EXPR: {
		fprintf(f,"INNER%sEXPR",separator);break;
	}

	case NODE_COMPARE_EXPR: {
		fprintf(f,"COMPARE%sEXPR",separator);break;
	}

	case NODE_COMPARE_OPERATOR: {
		fprintf(f,"COMPARE%sOPERATOR",separator);break;
	}

	case NODE_LOGIC_EXPR: {
		fprintf(f,"LOGIC%sEXPR",separator);break;
	}

	case NODE_LOGIC_OPERATOR: {
		fprintf(f,"LOGIC%sOPERATOR",separator);break;
	}

	case NODE_MATH_EXPR_1: {
		fprintf(f,"MATH%sEXPR%s1",separator,separator);break;
	}

	case NODE_MATH_EXPR_2: {
		fprintf(f,"MATH%sEXPR%s2",separator,separator);break;
	}

	case NODE_TERM_EXPR: {
		fprintf(f,"TERM%sEXPR",separator);break;
	}

	case NODE_CONSTANT: {
		fprintf(f,"CONSTANT");break;
	}

	case NODE_CLASS_DEFINITION: {
		fprintf(f,"CLASS%sDEFINITION",separator);break;
	}

	case NODE_ADDITIONAL_CLAUSES_SECTOR: {
		fprintf(f,"ADDITIONAL%sCLAUSES%sSECTOR",separator,separator);break;
	}

	case NODE_ADDITIONAL_CLAUSE_LIST: {
		fprintf(f,"ADDITIONAL%sCLAUSE%sLIST",separator,separator);break;
	}

	case NODE_ADDITIONAL_CLAUSE: {
		fprintf(f,"ADDITIONAL%sCLAUSE",separator);break;
	}

	case NODE_EXTENDS_CLAUSE: {
		fprintf(f,"EXTENDS%sCLAUSE",separator);break;
	}

	case NODE_GROUP_MEMBER_CLAUSE: {
		fprintf(f,"GROUP%sMEMBER%sCLAUSE",separator,separator);break;
	}

	case NODE_STAT_SECTOR: {
		fprintf(f,"STAT%sSECTOR",separator);break;
	}

	case NODE_STAT_LIST: {
		fprintf(f,"STAT%sLIST",separator);break;
	}

	case NODE_STAT: {
		fprintf(f,"STAT");break;
	}

	case NODE_LOCAL_VARIABLE: {
		fprintf(f,"LOCAL%sVARIABLE",separator);break;
	}

	case NODE_ASSIGN_STAT: {
		fprintf(f,"ASSIGN%sSTAT",separator);break;
	}

	case NODE_WHILE_STAT: {
		fprintf(f,"WHILE%sSTAT",separator);break;
	}

	case NODE_DO_WHILE_STAT: {
		fprintf(f,"DO%sWHILE%sSTAT",separator,separator);break;
	}

	case NODE_FOR_STAT: {
		fprintf(f,"FOR%sSTAT",separator);break;
	}

	case NODE_IF_STAT: {
		fprintf(f,"IF%sSTAT",separator);break;
	}
	case NODE_ELSIF_ELSE_STAT_SECTOR: {
		fprintf(f,"NODE%sELSIF%sELSE%sSTAT%sSECTOR",separator,separator,separator,separator);break;
	}

	case NODE_ELSIF_ELSE_STAT_LIST: {
		fprintf(f,"ELSIF%sSTAT%sLIST",separator,separator);break;
	}

	case NODE_ELSIF_STAT: {
		fprintf(f,"ELSIF%sSTAT",separator);break;
	}

	case NODE_ELSE_STAT: {
		fprintf(f,"ELSE%sSTAT",separator);break;
	}

	case NODE_SWITCH_STAT: {
		fprintf(f,"SWITCH%sSTAT",separator);break;
	}

	case NODE_SWITCH_LIST: {
		fprintf(f,"SWITCH%sLIST",separator);break;
	}

	case NODE_CASE_CLAUSE_LIST: {
		fprintf(f,"CASE%sCLAUSE%sLIST",separator,separator);break;
	}

	case NODE_CASE_CLAUSE: {
		fprintf(f,"CASE%sCLAUSE",separator);break;
	}

	case NODE_DEFAULT_CLAUSE: {
		fprintf(f,"DEFAULT%sCLAUSE",separator);break;
	}

	case NODE_CONTINUE_STAT: {
		fprintf(f,"CONTINUE%sSTAT",separator);break;
	}

	case NODE_BREAK_STAT: {
		fprintf(f,"BREAK%sSTAT",separator);break;
	}

	case NODE_RETURN_STAT: {
		fprintf(f,"RETURN%sSTAT",separator);break;
	}

	case NODE_CHARCONST: {
		fprintf(f,"CHARCONST");break;
	}

	case NODE_INTCONST: {
		fprintf(f,"INTCONST");break;
	}

	case NODE_FLOATCONST: {
		fprintf(f,"FLOATCONST");break;
	}

	case NODE_STRINGCONST: {
		fprintf(f,"STRINGCONST");break;
	}

	case NODE_BOOLCONST: {
		fprintf(f,"BOOLCONST");break;
	}

	case NODE_ID: {
		fprintf(f,"ID");break;
	}

	case NODE_INT_TYPE: {
		fprintf(f,"INT%sTYPE",separator);break;
	}

	case NODE_CHAR_TYPE: {
		fprintf(f,"CHAR%sTYPE",separator);break;
	}

	case NODE_FLOAT_TYPE: {
		fprintf(f,"FLOAT%sTYPE",separator);break;
	}

	case NODE_STRING_TYPE: {
		fprintf(f,"STRING%sTYPE",separator);break;
	}

	case NODE_BOOL_TYPE: {
		fprintf(f,"BOOL%sTYPE",separator);break;
	}

	case NODE_PUBLIC: {
		fprintf(f,"PUBLIC");break;
	}

	case NODE_PACKAGE: {
		fprintf(f,"PACKAGE");break;
	}

	case NODE_ALL: {
		fprintf(f,"ALL");break;
	}

	case NODE_ONLYME: {
		fprintf(f,"ONLYME");break;
	}

	case NODE_CHILDREN: {
		fprintf(f,"CHILDREN");break;
	}

	case NODE_ABSTRACT: {
		fprintf(f,"ABSTRACT");break;
	}

	case NODE_CONST: {
		fprintf(f,"CONST");break;
	}

	case NODE_STATIC: {
		fprintf(f,"STATIC");break;
	}

	case NODE_REFERENCE: {
		fprintf(f,"REFERENCE");break;
	}

	case NODE_VALUE: {
		fprintf(f,"VALUE");break;
	}

	case NODE_VOID: {
		fprintf(f,"VOID");break;
	}

	case NODE_REAL: {
		fprintf(f,"REAL");break;
	}

	case NODE_COPY: {
		fprintf(f,"COPY");break;
	}

	case NODE_THIS: {
		fprintf(f,"THIS");break;
	}

	case NODE_RETURN: {
		fprintf(f,"RETURN");break;
	}

	case NODE_BREAK: {
		fprintf(f,"BREAK");break;
	}

	case NODE_CONTINUE: {
		fprintf(f,"CONTINUE");break;
	}

	case NODE_PLUS: {
		fprintf(f,"PLUS");break;
	}

	case NODE_MINUS: {
		fprintf(f,"MINUS");break;
	}
	case NODE_TIMES: {
		fprintf(f,"TIMES");break;
	}
	case NODE_DIVISION: {
		fprintf(f,"DIVISION");break;
	}
	case NODE_REMAINDER: {
		fprintf(f,"REMAINDER");break;
	}
	case NODE_AND: {
		fprintf(f,"AND");break;
	}
	case NODE_OR: {
		fprintf(f,"OR");break;
	}
	case NODE_LEQ: {
		fprintf(f,"LEQ");break;
	}
	case NODE_GEQ: {
		fprintf(f,"GEQ");break;
	}
	case NODE_LT: {
		fprintf(f,"LT");break;
	}
	case NODE_GT: {
		fprintf(f,"GT");break;
	}
	case NODE_EQ: {
		fprintf(f,"EQ");break;
	}
	case NODE_NE: {
		fprintf(f,"NE");break;
	}
	case NODE_OPPOSITE: {
		fprintf(f,"OPPOSITE");break;
	}
	case NODE_NEGATIVE: {
		fprintf(f,"NEGATIVE");break;
	}
	}
}
